In [1]:
import plotly.express as px
import numpy as np
import plotly.graph_objects as go
import networkx as nx
import itertools
import pathpy as pp
import ast
In [2]:
def temporal_walk(tempnet, l=10, start_node=None, end_nodes=[]):
    itinerary = []
    if start_node is None:
        current_node = np.random.choice(tempnet.nodes)
    else:
        current_node = start_node
    itinerary.append(current_node)
    steps = 0
    for t in tempnet.ordered_times:
        prev_node = current_node
        # find possible targets in time t
        targets = set()
        targets.add(False)
        for (v, w, time) in tempnet.time[t]:
            if v == current_node:
                targets.add(w)
        # move to random target or stay if False is extracted
        if targets:
            rand_node = np.random.choice(list(targets))
            if (rand_node!=False):
                current_node = rand_node
                steps += 1
        # add currently visited node
        if current_node != prev_node:
            itinerary.append(current_node)
        if steps == l:
            break
        if current_node in end_nodes :
            break
    return itinerary
In [3]:
from pathpy.classes.paths import Paths
def paths_from_temporal_walk(network, l, n=100, start_node=None, end_nodes=[]):
    """
    Generates n paths of a random walker in the given network
    and returns them as a paths object.
    Each path has a length of l steps.
    Parameters
    ----------
    network: Network, TemporalNetwork, HigherOrderNetwork
        The network structure on which the random walks will be simulated.
    int: l
        The (maximum) length of each random walk path. A path will
        terminate if a node with outdegree zero is reached.
    int: n
        The number of random walk paths to generate.
    """
    p = pp.Paths()
    for i in range(n):
        path = temporal_walk(network, l, start_node, end_nodes)
        p.add_path(tuple(path))
    return p
In [4]:
file=open(r"C:\Users\Daniele\Desktop\Graph mining\icalp.tg")
max_v=0
for line in file:
    a=line.split()
    max_v=max(max_v,int(a[0]),int(a[1]))
G=nx.Graph()
G.add_nodes_from(range(1,max_v+1))
In [5]:
file=open(r"C:\Users\Daniele\Desktop\Graph mining\icalp.tg")
for line in file:
    a=line.split()
    G.add_edge(int(a[0]),int(a[1]))
nx.Graph.number_of_nodes(G)
Out[5]:
4669
In [6]:
largest_cc = max(nx.connected_components(G), key=len)
G=G.subgraph(largest_cc)
nx.Graph.number_of_nodes(G)
Out[6]:
3458
In [7]:
# TAKE ABOUT 5 MINUTES TO BE COMPUTED

# dict_centrality=nx.algorithms.centrality.betweenness_centrality(G,seed=42)
# f = open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorDictCentrality.txt", "w")
# f.write( str(dict_centrality) )
# f.close()
In [8]:
f = open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorDictCentrality.txt", "r")
contents = f.read()
dict_centrality = ast.literal_eval(contents)
f.close()
In [9]:
with open(r"C:\Users\Daniele\Desktop\Graph mining\graphs\icalpw\icalpw2021map.txt",'r') as f:
    lines = f.readlines()

id_cc=[]
for line in lines:
    id_cc.append(int(line))
In [ ]:
In [10]:
with open(r"C:\Users\Daniele\Desktop\Graph mining\icalp_id_author.txt",'r') as f:
    lines = f.readlines()
dict_names={}
for line in lines:
    dict_names[int(line.split(" ")[0])]=line.strip(" 1234567890").replace("\n","")
In [ ]:
In [11]:
authors_algorithms=[487,1198,1856,2189,78]
for auth in authors_algorithms:
    print(dict_names[auth])

Paul G. Spirakis
Piotr Indyk
Fedor V. Fomin
Dániel Marx
Kurt Mehlhorn
In [12]:
authors_formal_methods=[381,944,1625,1240,1333]
for auth in authors_formal_methods:
    print(dict_names[auth])

Donald Sannella
Anca Muscholl
James Worrell 0001
Christel Baier
Igor Walukiewicz
In [13]:
authors_networks=[2662,1857,1100,1215,1152]
for auth in authors_networks:
    print(dict_names[auth])

Ioannis Chatzigiannakis
Mohammad Taghi Hajiaghayi
Stefano Leonardi
Christos Kaklamanis
Michael Mitzenmacher
In [14]:
authors_cryptography=[523,1491,930,1588, 738]
for auth in authors_cryptography:
    print(dict_names[auth])

Moti Yung
Rafail Ostrovsky
Giuseppe Persiano
Yuval Ishai
Gilles Brassard
In [15]:
authors_chosen=authors_algorithms+authors_formal_methods+authors_networks+authors_cryptography
In [16]:
map_auth_consolidate = {}
for i in range(1,max_v+1):
    if (i in authors_algorithms or i in authors_formal_methods or i in authors_networks or i in authors_cryptography):
        
        if (i in authors_algorithms):
            map_auth_consolidate[i]=5000
            
        elif (i in authors_formal_methods):
            map_auth_consolidate[i]=6000
            
        elif (i in authors_networks):
            map_auth_consolidate[i]=7000
        else:
            map_auth_consolidate[i]=8000
    else:
        map_auth_consolidate[i]=i
In [17]:
file=open(r"C:\Users\Daniele\Desktop\Graph mining\icalp.tg")
tg=pp.TemporalNetwork()
for line in file:
    l=line.split()
    u=int(l[0])
    v=int(l[1])
    time=int(l[2])
    if (u in largest_cc and v in largest_cc):
        if ( map_auth_consolidate[u] == map_auth_consolidate[v] ):
            continue
        tg.add_edge(map_auth_consolidate[u],map_auth_consolidate[v],time)
        tg.add_edge(map_auth_consolidate[v],map_auth_consolidate[u],time)
print(tg)

Nodes:			3442
Time-stamped links:	18574
Links/Nodes:		5.396281231841952
Observation period:	[1972, 2021]
Observation length:	 49 
Time stamps:		 48 
Avg. inter-event dt:	 1.0425531914893618
Min/Max inter-event dt:	 1/2
In [18]:
def get_frequencies(tg,l,n,start_node,end_nodes):
    prw = paths_from_temporal_walk(tg,l,n,start_node,end_nodes)
    count=0
    f_algo=0
    f_formal=0
    f_net=0
    f_crypto=0
    for l in prw.paths:
        for x in prw.paths[l]:
            if prw.paths[l][x][1]>0 and int(x[-1]) in end_nodes:
                count= count+ prw.paths[l][x][1]
                if int(x[-1])==5000:
                    f_algo= f_algo + prw.paths[l][x][1]
                elif int(x[-1])==6000:
                    f_formal= f_formal + prw.paths[l][x][1]
                elif int(x[-1])==7000:
                    f_net= f_net + prw.paths[l][x][1]
                else:
                    f_crypto= f_crypto + prw.paths[l][x][1]
    if count>0:
        return (f_algo/count,f_formal/count,f_net/count,f_crypto/count)
    else:
        return (0,0,0,0)
In [19]:
# TOOK ABOUT 10 HOURS TO BE COMPUTED

# dict_frequency={}

# for auth in authors_algorithms:
#     dict_frequency[auth]=(1,0,0,0)
# for auth in authors_formal_methods:
#     dict_frequency[auth]=(0,1,0,0)
# for auth in authors_networks:
#     dict_frequency[auth]=(0,0,1,0)
# for auth in authors_cryptography:
#     dict_frequency[auth]=(0,0,0,1)

# for vertex in [ v for v in largest_cc if v not in authors_chosen ]:
#     dict_frequency[vertex]=get_frequencies(tg,l=7,n=3000,start_node=vertex,end_nodes=[5000,6000,7000,8000])


# f = open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorDictFrequencies.txt", "w")
# f.write( str(dict_frequency) )
# f.close()
In [20]:
f = open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorDictFrequencies.txt", "r")
contents = f.read()
dict_frequency = ast.literal_eval(contents)
f.close()
In [21]:
dict_frequency_2={}
for vertex in largest_cc:
    (a,b,c,d)=dict_frequency[vertex]
    dict_frequency_2[vertex]=(1 if a>=0.9 else 0, 1 if b>=0.9 else 0,1 if c>=0.9 else 0,1 if d>=0.9 else 0)
    
aut_classified=[[],[],[],[]]
aut_to_classify=[]
for key,value in dict_frequency_2.items():
    if value==(0,0,0,0):
        aut_to_classify.append(key)
    else:
        aut_classified[np.argmax(value)].append(key)
min_cat=min(len(aut_classified[0]),len(aut_classified[1]),len(aut_classified[2]),len(aut_classified[3]))

aut_algo_temp=sorted(aut_classified[0], key=lambda aut:dict_centrality[aut],reverse=True)[0:min_cat]
for aut in list(set(aut_classified[0])-set(aut_algo_temp)):
    dict_frequency_2[aut]=(0,0,0,0)
    aut_to_classify.append(aut)
aut_classified[0]=aut_algo_temp

aut_formal_temp=sorted(aut_classified[1], key=lambda aut:dict_centrality[aut],reverse=True)[0:min_cat]
for aut in list(set(aut_classified[1])-set(aut_formal_temp)):
    dict_frequency_2[aut]=(0,0,0,0)
    aut_to_classify.append(aut)
aut_classified[1]=aut_formal_temp
    
aut_net_temp=sorted(aut_classified[2], key=lambda aut:dict_centrality[aut],reverse=True)[0:min_cat]
for aut in list(set(aut_classified[2])-set(aut_net_temp)):
    dict_frequency_2[aut]=(0,0,0,0)
    aut_to_classify.append(aut)
aut_classified[2]=aut_net_temp

    
aut_crypto_temp=sorted(aut_classified[3], key=lambda aut:dict_centrality[aut],reverse=True)[0:min_cat]
for aut in list(set(aut_classified[3])-set(aut_crypto_temp)):
    dict_frequency_2[aut]=(0,0,0,0)
    aut_to_classify.append(aut)
aut_classified[3]=aut_crypto_temp
In [22]:
map_auth_consolidate = {}
for i in range(1,max_v+1):
    if (i in aut_classified[0] or i in aut_classified[1] or i in aut_classified[2] or i in aut_classified[3]):
        
        if (i in aut_classified[0]):
            map_auth_consolidate[i]=5000
            
        elif (i in aut_classified[1]):
            map_auth_consolidate[i]=6000
            
        elif (i in aut_classified[2]):
            map_auth_consolidate[i]=7000
        else:
            map_auth_consolidate[i]=8000
    else:
        map_auth_consolidate[i]=i
In [23]:
file=open(r"C:\Users\Daniele\Desktop\Graph mining\icalp.tg")
tg=pp.TemporalNetwork()
for line in file:
    l=line.split()
    u=int(l[0])
    v=int(l[1])
    time=int(l[2])
    if (u in largest_cc and v in largest_cc):
        if ( map_auth_consolidate[u] == map_auth_consolidate[v] ):
            continue
        tg.add_edge(map_auth_consolidate[u],map_auth_consolidate[v],time)
        tg.add_edge(map_auth_consolidate[v],map_auth_consolidate[u],time)
print(tg)

Nodes:			2838
Time-stamped links:	15650
Links/Nodes:		5.514446793516561
Observation period:	[1972, 2021]
Observation length:	 49 
Time stamps:		 48 
Avg. inter-event dt:	 1.0425531914893618
Min/Max inter-event dt:	 1/2
In [24]:
#started 15:30
# for vertex in aut_to_classify:
#     dict_frequency_2[vertex]=get_frequencies(tg,l=7,n=3000,start_node=vertex,end_nodes=[5000,6000,7000,8000])
#end 18:
In [25]:
# f = open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorDictFrequencies2.txt", "w")
# f.write( str(dict_frequency_2) )
# f.close()
In [26]:
f = open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorDictFrequencies2.txt", "r")
contents = f.read()
dict_frequency_2 = ast.literal_eval(contents)
f.close()
In [27]:
dict_frequency_3={}
for vertex in largest_cc:
    (a,b,c,d)=dict_frequency_2[vertex]
    dict_frequency_3[vertex]=(1 if a>=0.9 else 0, 1 if b>=0.9 else 0,1 if c>=0.9 else 0,1 if d>=0.9 else 0)
    
aut_classified=[[],[],[],[]]
aut_to_classify=[]
for key,value in dict_frequency_2.items():
    if value==(0,0,0,0):
        aut_to_classify.append(key)
    else:
        aut_classified[np.argmax(value)].append(key)
min_cat=min(len(aut_classified[0]),len(aut_classified[1]),len(aut_classified[2]),len(aut_classified[3]))

aut_algo_temp=sorted(aut_classified[0], key=lambda aut:dict_centrality[aut],reverse=True)[0:min_cat]
for aut in list(set(aut_classified[0])-set(aut_algo_temp)):
    dict_frequency_2[aut]=(0,0,0,0)
    aut_to_classify.append(aut)
aut_classified[0]=aut_algo_temp

aut_formal_temp=sorted(aut_classified[1], key=lambda aut:dict_centrality[aut],reverse=True)[0:min_cat]
for aut in list(set(aut_classified[1])-set(aut_formal_temp)):
    dict_frequency_2[aut]=(0,0,0,0)
    aut_to_classify.append(aut)
aut_classified[1]=aut_formal_temp
    
aut_net_temp=sorted(aut_classified[2], key=lambda aut:dict_centrality[aut],reverse=True)[0:min_cat]
for aut in list(set(aut_classified[2])-set(aut_net_temp)):
    dict_frequency_2[aut]=(0,0,0,0)
    aut_to_classify.append(aut)
aut_classified[2]=aut_net_temp

    
aut_crypto_temp=sorted(aut_classified[3], key=lambda aut:dict_centrality[aut],reverse=True)[0:min_cat]
for aut in list(set(aut_classified[3])-set(aut_crypto_temp)):
    dict_frequency_2[aut]=(0,0,0,0)
    aut_to_classify.append(aut)
aut_classified[3]=aut_crypto_temp
In [28]:
for aut in aut_classified:
    print(len(aut))

415
415
415
415
In [29]:
map_auth_consolidate = {}
for i in range(1,max_v+1):
    if (i in aut_classified[0] or i in aut_classified[1] or i in aut_classified[2] or i in aut_classified[3]):
        
        if (i in aut_classified[0]):
            map_auth_consolidate[i]=5000
            
        elif (i in aut_classified[1]):
            map_auth_consolidate[i]=6000
            
        elif (i in aut_classified[2]):
            map_auth_consolidate[i]=7000
        else:
            map_auth_consolidate[i]=8000
    else:
        map_auth_consolidate[i]=i
In [30]:
file=open(r"C:\Users\Daniele\Desktop\Graph mining\icalp.tg")
tg=pp.TemporalNetwork()
for line in file:
    l=line.split()
    u=int(l[0])
    v=int(l[1])
    time=int(l[2])
    if (u in largest_cc and v in largest_cc):
        if ( map_auth_consolidate[u] == map_auth_consolidate[v] ):
            continue
        tg.add_edge(map_auth_consolidate[u],map_auth_consolidate[v],time)
        tg.add_edge(map_auth_consolidate[v],map_auth_consolidate[u],time)
print(tg)

Nodes:			1802
Time-stamped links:	10830
Links/Nodes:		6.009988901220866
Observation period:	[1972, 2021]
Observation length:	 49 
Time stamps:		 48 
Avg. inter-event dt:	 1.0425531914893618
Min/Max inter-event dt:	 1/2
In [31]:
# # #started 02:00
# for vertex in aut_to_classify:
#     dict_frequency_3[vertex]=get_frequencies(tg,l=7,n=3000,start_node=vertex,end_nodes=[5000,6000,7000,8000])
# #end
In [32]:
# f = open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorDictFrequencies3.txt", "w")
# f.write( str(dict_frequency_3) )
# f.close()
In [33]:
f = open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorDictFrequencies3.txt", "r")
contents = f.read()
dict_frequency_3 = ast.literal_eval(contents)
f.close()
In [ ]:
In [34]:
dict_classification={}
for vertex in dict_frequency.keys():
    if (dict_frequency_3[vertex]==(0,0,0,0)) or (sorted(dict_frequency_3[vertex],reverse=True)[0]- sorted(dict_frequency_3[vertex],reverse=True)[1] <0.2): 
        dict_classification[vertex]=4
        continue
    dict_classification[vertex]=np.argmax(dict_frequency_3[vertex])
In [35]:
nc=0
und=0
na=0
nfm=0
ncr=0
nn=0
for v in [ v for v in largest_cc if v not in authors_chosen ]:
    if(dict_classification[v]==4):
        nc=nc+1
        if dict_frequency_3[v]!=(0,0,0,0):
            und+=1
            continue
        
    if(dict_classification[v]==0):
        na=na+1
    if(dict_classification[v]==1):
        nfm=nfm+1
    if(dict_classification[v]==2):
        nn=nn+1
    if(dict_classification[v]==3):
        ncr=ncr+1
print("Non classified authors = "+str(nc)+"\nUndetermined authors = "+str(und)+"\nAlgorithms authors = "+str(na)+"\nFormal methods authors = "+str(nfm)+"\nNetworks authors = "+str(nn)+"\nCryptography authors = "+str(ncr))

Non classified authors = 736
Undetermined authors = 202
Algorithms authors = 1141
Formal methods authors = 698
Networks authors = 457
Cryptography authors = 406
In [36]:
matrix_mvsj=np.load(r"C:\Users\Daniele\Desktop\Graph mining\graphs\icalpw\icalpw2021_mvsMatrixJulia3D.npy")
In [37]:
arr_names=[]
for i in range(np.shape(matrix_mvsj)[1]):
    arr_names.append(dict_names[id_cc[i]])
In [38]:
colors=["red","blue","green","yellow","black"]
arr_color=[]
for i in range(np.shape(matrix_mvsj)[1]):
    arr_color.append(colors[dict_classification[id_cc[i]]])
In [39]:
fig=go.Figure(data=[go.Scatter3d(x=matrix_mvsj[0],y=matrix_mvsj[1],z=matrix_mvsj[2],text=arr_names,mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [40]:
matrix2d_mvsj=np.load(r"C:\Users\Daniele\Desktop\Graph mining\graphs\icalpw\icalpw2021_mvsMatrixJulia2D.npy")
In [43]:
fig = go.Figure(data=go.Scatter(x=matrix2d_mvsj[0], y=matrix2d_mvsj[1],text=arr_names, mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )))
fig.show()
In [ ]:
In [ ]:
In [44]:
dist_matrix=np.load(r"C:\Users\Daniele\Desktop\Graph mining\graphs\icalpw\icalpw2021_distMatrix.npy")
In [45]:
# from sklearn.manifold import MDS
# embedding = MDS(n_components=3,dissimilarity='precomputed')
# G_transform = embedding.fit_transform(dist_matrix/np.max(dist_matrix))
#np.save(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixMVSPython.npy",G_transform)
In [46]:
G_transform= np.load(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixMVSPython.npy")
In [ ]:
In [47]:
fig=go.Figure(data=[go.Scatter3d(x=G_transform[:,0],y=G_transform[:,1],z=G_transform[:,2],text=arr_names,mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [ ]:
In [ ]:
In [48]:
matrix_mvsj_leven=np.load(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixDissimilarityLevenshtein1MVSPython.npy")
In [49]:
np.shape(matrix_mvsj_leven)
Out[49]:
(3458, 3)
In [50]:
fig=go.Figure(data=[go.Scatter3d(x=matrix_mvsj_leven[:,0],y=matrix_mvsj_leven[:,1],z=matrix_mvsj_leven[:,2],text=arr_names,mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [51]:
matrix_mvsj_leven=np.load(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixDissimilarityLevenshtein1MVSJulia.npy")
In [52]:
fig=go.Figure(data=[go.Scatter3d(x=matrix_mvsj_leven[0],y=matrix_mvsj_leven[1],z=matrix_mvsj_leven[2],text=arr_names,mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [ ]:
In [53]:
# import nltk
# # nltk.download('stopwords')
# from nltk.corpus import stopwords
In [54]:
# lemmer = nltk.stem.WordNetLemmatizer()
# def LemTokens(tokens):
#     return [lemmer.lemmatize(token) for token in tokens]
# remove_punct_dict = dict((ord(punct), None) for punct in string.punctuation)
# def LemNormalize(text):
#     return LemTokens(nltk.word_tokenize(text.lower().translate(remove_punct_dict)))
In [55]:
# file=open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorsWithPaperTitles.txt")
# dict_auth_titles={}
# stopWords = set(stopwords.words('english'))
# while True:
#     auth=file.readline()
#     if (auth):
#         auth_id=int(auth)
#         if auth_id in largest_cc:
#             #print(auth_id)
#             count=0
#             #titles=""
#             t=file.readline()
#             while(t!="\n"):
#                 t=t.split("...")[0]
#                 t=t.replace("-"," ")
#                 t=re.sub(" \d+"," ",t)
#                 temp=LemNormalize(t)
#                 if auth_id in dict_auth_titles.keys():
#                     dict_auth_titles[auth_id]=dict_auth_titles[auth_id]+[t for t in temp if len(t)>2 and t not in stopWords]
#                 else:
#                     dict_auth_titles[auth_id]=[t for t in temp if len(t)>2 and t not in stopWords]
#                 t=file.readline()
#             if len(dict_auth_titles[auth_id])==0 : print(auth_id)
#         else:
#             titles=""
#             t=file.readline()
#             while(t!="\n"):
#                 titles=titles+" "+t
#                 t=file.readline()
        
#     else:
#         break
In [56]:
# titles=[]
# for auth in sorted(dict_auth_titles):
#     title=""
#     for t in dict_auth_titles[auth]:
#         title=title+" "+t
#     titles.append(title)
# titles
In [57]:
# from sklearn.feature_extraction.text import TfidfVectorizer
# TfidfVec = TfidfVectorizer(tokenizer=LemNormalize, stop_words='english')
# def cos_similarity(textlist):
#     tfidf = TfidfVec.fit_transform(textlist)
#     return (tfidf * tfidf.T).toarray()
# matrix=cos_similarity(titles)
# matrix=1-matrix
# np.save(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixTitles.npy",matrix)
In [58]:
# from sklearn.manifold import MDS
# embedding = MDS(n_components=3,dissimilarity='precomputed')
# G_transform = embedding.fit_transform(matrix)
# print(G_transform.shape)
# np.save(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixTitles_mvsPython.npy",G_transform)
In [ ]:
In [ ]:
In [62]:
matrix_mvsj_cosine_sim=np.load(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixTitles_mvsJulia3D.npy")
In [63]:
fig=go.Figure(data=[go.Scatter3d(x=matrix_mvsj_cosine_sim[0],y=matrix_mvsj_cosine_sim[1],z=matrix_mvsj_cosine_sim[2],text=arr_names,mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [64]:
matrix_mvsj_cosine_sim2d=np.load(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixTitles_mvsJulia2D.npy")
In [69]:
fig=go.Figure(data=[go.Scatter(x=matrix_mvsj_cosine_sim2d[0],y=matrix_mvsj_cosine_sim2d[1],text=arr_names,mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [ ]:
In [ ]:
In [70]:
matrix_mvsp_cosine_sim=np.load(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixTitles_mvsPython.npy")
In [71]:
fig=go.Figure(data=[go.Scatter3d(x=matrix_mvsp_cosine_sim[:,0],y=matrix_mvsp_cosine_sim[:,1],z=matrix_mvsp_cosine_sim[:,2],text=arr_names,mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [ ]:
In [72]:
# dist_matrix=np.load(r"C:\Users\Daniele\Desktop\Graph mining\graphs\icalpw\icalpw2021_distMatrix.npy")
# dist_matrix=dist_matrix/np.max(dist_matrix)
# titles_dissim_matrix=np.load(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixTitles.npy")
# combined_matrix=(dist_matrix/2) + (titles_dissim_matrix/2)
#np.save(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixCombined.npy",combined_matrix)
In [73]:
combined_matrix_mvsj=np.load(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixCombined_mvsJulia3D.npy")
In [74]:
fig=go.Figure(data=[go.Scatter3d(x=combined_matrix_mvsj[0],y=combined_matrix_mvsj[1],z=combined_matrix_mvsj[2],text=arr_names,mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [75]:
combined_matrix_mvsj2d=np.load(r"C:\Users\Daniele\Desktop\Graph mining\icalpMatrixCombined_mvsJulia2D.npy")
In [79]:
fig=go.Figure(data=[go.Scatter(x=combined_matrix_mvsj2d[0],y=combined_matrix_mvsj2d[1],text=arr_names,mode='markers',marker=dict(
            color=arr_color,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [ ]:
In [ ]:
In [ ]:
In [80]:
f = open(r"C:\Users\Daniele\Desktop\Graph mining\icalpAuthorDictFrequenciesAllEdgesNoGiant3.txt", "r")
contents = f.read()
dict_frequency_3_ng = ast.literal_eval(contents)
f.close()
In [81]:
dict_classification_ng={}
for auth in authors_algorithms:
    dict_frequency_3_ng[auth]=(1,0,0,0)
for auth in authors_formal_methods:
    dict_frequency_3_ng[auth]=(0,1,0,0)
for auth in authors_networks:
    dict_frequency_3_ng[auth]=(0,0,1,0)
for auth in authors_cryptography:
    dict_frequency_3_ng[auth]=(0,0,0,1)
for vertex in largest_cc:
    if (dict_frequency_3_ng[vertex]==(0,0,0,0)) or (sorted(dict_frequency_3_ng[vertex],reverse=True)[0]- sorted(dict_frequency_3_ng[vertex],reverse=True)[1] <0.2): 
        dict_classification_ng[vertex]=4
        continue
    dict_classification_ng[vertex]=np.argmax(dict_frequency_3_ng[vertex])
In [82]:
colors=["red","blue","green","yellow","black"]
arr_color_ng=[]
for i in range(np.shape(matrix_mvsj)[1]):
    arr_color_ng.append(colors[dict_classification_ng[id_cc[i]]])
In [83]:
fig=go.Figure(data=[go.Scatter3d(x=matrix_mvsj[0],y=matrix_mvsj[1],z=matrix_mvsj[2],text=arr_names,mode='markers',marker=dict(
            color=arr_color_ng,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [84]:
fig=go.Figure(data=[go.Scatter3d(x=G_transform[:,0],y=G_transform[:,1],z=G_transform[:,2],text=arr_names,mode='markers',marker=dict(
            color=arr_color_ng,
            size=3,
            sizemode='diameter'
        )
    )])
fig.show()
In [ ]: